memcached 内存初始化与key-value存储
本次笔记未涉及到slab的动态重新平衡分配
/**首先介绍一下一个跟内存相关的非常重要的概念，内存块类型数据结构:*/
typedef struct {
unsigned int size; /* chunk的大小 sizes of items */
unsigned int perslab; /* 整个slab有chunk的数量 how many items per slab */
void *slots; /* item串起来的链表 list of item ptrs */
unsigned int sl_curr; /* 当前slabclass 有多少可用的 chunk total free items in list */
unsigned int slabs; /* 之前已经分配这种类型slab的数量 how many slabs were allocated for this class */
void **slab_list; /* 同类型的slab构成一个数组 array of slab pointers */
unsigned int list_size; /* 已经分配空间的slab_list的数组长度，实际使用数量为slabs size of prev array */
unsigned int killing; /* index+1 of dying slab, or zero if none */
size_t requested; /* 已经被申请使用的字节数 The number of requested bytes */
} slabclass_t;
static slabclass_t slabclass[MAX_NUMBER_OF_SLAB_CLASSES]; /** 全局变量存储了系统所有的slab块类型*/
static size_t mem_limit = 0;
static size_t mem_malloced = 0;
static int power_largest; /** 记录有多少种slab块类型*/
static void *mem_base = NULL; /** 指向最初向系统申请的那大片空间，默认64M*/
static void *mem_current = NULL; /** 指向当前系统申请大片空间的首地址*/
static size_t mem_avail = 0; /** 统计系统申请的大片空间还有多少字节可以用*/
/*
* Figures out which slab class (chunk size) is required to store an item of
* a given size.
*
* Given object size, return id to use when allocating/freeing memory for object
* 0 means error: can't store such a large object
*/
/**
* 计算出哪一个slab class 适合存储一个size长度的item, 返回0 表示无法存储这个item
*/
unsigned int slabs_clsid(const size_t size) {
int res = POWER_SMALLEST;
if (size == 0)
return 0;
while (size > slabclass[res].size)
if (res++ == power_largest) /* won't fit in the biggest slab */
return 0;
return res;
}
/**
* Determines the chunk sizes and initializes the slab class descriptors
* accordingly.
*/
/**
* 确定chunk的大小并初始化slab的类型
* @limit 总的申请的内存块的大小 默认为 64M
* @相邻slab 之间的chunck大小进阶因子，比如第一种slab_class1的chunk为48 bytes,第二种slab_class2的chunk大小就为48*factor,第三种48*factor^2...
*/
/**
* slabs_init 主要逻辑,初始化内存块类型
* 首先理解一下memcached内存的划分逻辑，memcached在启动时会一次性向系统申请一大块内存，根据启动参数决定申请的大小，
* 默认为64M，之后便不再会向系统申请内存，而是在已申请的大块内存数组里面划分，少了系统调用，所以速度提高了。
* 获得一大块内存之后，memcached开始基于这块内存进行使用以及管理，首先是定义了内存块的概念，每一块默认大小为1M，
* 之后再对这一块内存进行划分为每一个chunk,每一个1M块里面的chunks都是一样大小的，不同的1M块包含的chunks的大小会有不同，
* 因此便有了块的类型，memcached 用一个数组来存储所有的类型slabclass, 默认类型不超过200种。那么memcached其实是用来存储
* key-value结构的，所以作为内存粒度最小的chunk自然就是用来存key-value了，将key-value进行包装一下用一个结构来表示，名称
* 为item，item就包含了一对key-value的信息，因此item所占的空间即长度就决定了需要用哪一种chunk来存储，不同的key-value所对应
* 的item长度自然是不一样，因而就需要不同大小的chunk来存储，也就是不同类型的slabclass.因而memcached引入了一个factor参数，
* 这个factor参数就是用来生成不同的slabclass，比如slabcalss[0]的chunk的大小为48bytes,则slabclass[1]的chunk大小则为48*factor bytes,
* factoe默认为1.25,所以相同大小的两块1M内存，slabclass[1]划分出来的chunk数量就比slabclass[0]要少，但是每个chunk比较大些，大点的
* item也能存得下，但其实一切对内存进行划分的行为都会造成一定量的内存浪费，但是若便于管理内存，利大于弊也是能接受一点浪费的。
*/
void slabs_init(const size_t limit, const double factor, const bool prealloc) {
int i = POWER_SMALLEST - 1;
unsigned int size = sizeof(item) + settings.chunk_size; /** setting.chunk_size为默认的大小*/
mem_limit = limit;
if (prealloc) {
/* Allocate everything in a big chunk with malloc */
/** 一次性向系统申请一大块的内存*/
mem_base = malloc(mem_limit);
if (mem_base != NULL) {
mem_current = mem_base;
mem_avail = mem_limit;
} else {
fprintf(stderr, "Warning: Failed to allocate requested memory in"
" one large chunk.\nWill allocate in smaller chunks\n");
}
}
/** 初始化slabclass数组*/
memset(slabclass, 0, sizeof(slabclass));
/**
* 初始化内存块的类型，默认最多200种
* setting.items_size_max就表示了一块内存默认大小为1M
*/
while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {
/* 确定内存对齐? Make sure items are always n-byte aligned */
if (size % CHUNK_ALIGN_BYTES)
size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);
/** slabclass.size 表示适合存储的item的大小, 这里似乎忽略了chunk的概念，其实chunk就是用来存item的*/
slabclass[i].size = size;
/** slabclass.perslab 表示这块1M内存会有多少个item*/
slabclass[i].perslab = settings.item_size_max / slabclass[i].size;
/** 下一种slabclass chunk的大小*/
size *= factor;
...
}
}
/** 记录最终有多少种slabclass*/
power_largest = i;
/** 最后一种item的大小就是块的大小了，也就是item可能就是1M大小，一个1M内存块就存了1个item*/
slabclass[power_largest].size = settings.item_size_max;
slabclass[power_largest].perslab = 1;
...
/* for the test suite: faking of how much we've already malloc'd */
{
char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC");
if (t_initial_malloc) {
mem_malloced = (size_t)atol(t_initial_malloc);
}
}
/** 是否预分配*/
if (prealloc) {
slabs_preallocate(power_largest);
}
}
/**
* 系统启动时预分配内存块的主要逻辑
* @spec maxslabs 表示有多少种slabclass
*
* 预分配的效果就是为每一种slabclass初始化一个slab块，并将slab块划分为对应大小的chunks
* 预分配不是系统启动默认的，因为有可能分配的slab始终不会用到，浪费了存储空间，但是被用
* 到时由于已经分配好，直接可以使用，系统效率会高点，具体看存入的item实际大小的情况了
*/
static void slabs_preallocate (const unsigned int maxslabs) {
int i;
unsigned int prealloc = 0;
/* pre-allocate a 1MB slab in every size class so people don't get
confused by non-intuitive "SERVER_ERROR out of memory"
messages. this is the most common question on the mailing
list. if you really don't want this, you can rebuild without
these three lines. */
/**
* 为每一种slabclass预分配1个1M的块，并将其划分为对应大小的的chunks
*/
for (i = POWER_SMALLEST; i <= POWER_LARGEST; i++) {
if (++prealloc > maxslabs)
return;
if (do_slabs_newslab(i) == 0) { /** 具体看do_slabs_newslab()注释*/
fprintf(stderr, "Error while preallocating slab memory!\n"
"If using -L or other prealloc options, max memory must be "
"at least %d megabytes.\n", power_largest);
exit(1);
}
}
}
/** 登记到某一种类型的slab_list数组中*/
static int grow_slab_list (const unsigned int id) {
slabclass_t *p = &slabclass[id];
/** 如果数组没有空间再放多一个slab,就需要扩容数组*/
if (p->slabs == p->list_size) {
size_t new_size = (p->list_size != 0) ? p->list_size * 2 : 16;
void *new_list = realloc(p->slab_list, new_size * sizeof(void *));
if (new_list == 0) return 0;
p->list_size = new_size;
p->slab_list = new_list;
}
return 1;
}
/**
* 函数名描述函数功能:将一个slab page 拆分(成小块)添加到可用链表-_-
* 将(申请到的)内存首地址作为参数，根据id找到所属的slabclass类型，
* 找到对应的chunk大小，将每一个chunk添加到slabclass的slot链表，具体由do_slabs_free()操作
*/
static void split_slab_page_into_freelist(char *ptr, const unsigned int id) {
slabclass_t *p = &slabclass[id];
int x;
for (x = 0; x < p->perslab; x++) {
do_slabs_free(ptr, 0, id); /** */
ptr += p->size; /** 指针移动size的长度*/
}
}
/** 申请一个slab, id 表示所属的class*/
static int do_slabs_newslab(const unsigned int id) {
/** 找到所属的类型*/
slabclass_t *p = &slabclass[id];
/** 计算申请的长度*/
int len = settings.slab_reassign ? settings.item_size_max
: p->size * p->perslab;
char *ptr;
/** 先判断可申请长度是否满足，之后判断是否需要扩容slabclass中记录申请的slab的数组，最后申请内存*/
if ((mem_limit && mem_malloced + len > mem_limit && p->slabs > 0) ||
(grow_slab_list(id) == 0) ||
((ptr = memory_allocate((size_t)len)) == 0)) {
MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
return 0;
}
memset(ptr, 0, (size_t)len);
split_slab_page_into_freelist(ptr, id); /** 将这一页的内存块瓜分成各个chunk小块，添加到slabclass可用slots链表*/
/**在slabclass中的数组记录多分配一个slab*/
p->slab_list[p->slabs++] = ptr;
mem_malloced += len;
MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);
return 1;
}
/*@null@*/
/** 分配一个slab块 size 表示item的大小，id 表示slabclass id*/
static void *do_slabs_alloc(const size_t size, unsigned int id) {
slabclass_t *p;
void *ret = NULL;
item *it = NULL;
if (id < POWER_SMALLEST || id > power_largest) {
MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0);
return NULL;
}
p = &slabclass[id];
assert(p->sl_curr == 0 || ((item *)p->slots)->slabs_clsid == 0);
/* fail unless we have space at the end of a recently allocated page,
we have something on our freelist, or we could allocate a new page */
/* 先确保slabclass有咩有可用的slot, 再去申请新的slab, 申请也有可能失败*/
if (! (p->sl_curr != 0 || do_slabs_newslab(id) != 0)) {
/* We don't have more memory available */
ret = NULL;
} else if (p->sl_curr != 0) { /** 在slot有可用空间的时候申请失败则直接从slot那里取一个*/
/* return off our freelist */
it = (item *)p->slots;
p->slots = it->next;
if (it->next) it->next->prev = 0;
p->sl_curr--; /**更新可用的数量*/
ret = (void *)it;
}
if (ret) {
p->requested += size; /** 统计已经被使用的字节数量*/
MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret);
} else {
MEMCACHED_SLABS_ALLOCATE_FAILED(size, id);
}
return ret;
}
/** 按照函数名理解，释放一个slab块
* ptr 表示首地址，size表示item已使用字节大小，id是所属的slabclass
*/
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
item *it;
/** 判断参数合法性*/
assert(((item *)ptr)->slabs_clsid == 0);
assert(id >= POWER_SMALLEST && id <= power_largest);
if (id < POWER_SMALLEST || id > power_largest)
return;
MEMCACHED_SLABS_FREE(size, id, ptr);
p = &slabclass[id];
it = (item *)ptr; /** 转化(初始化)成item类型指针*/
it->it_flags |= ITEM_SLABBED;
it->prev = 0;
it->next = p->slots; /** 串在 slabcalss的slots链表头部*/
if (it->next) it->next->prev = it; /*下一个节点不为空时，将下一个节点的prev指向it*/
p->slots = it; /** 更新slots */
p->sl_curr++; /**更新当前可用的chunk数量, slot代表了链表的名称, sl_curr表示可用的数量*/
p->requested -= size; /** 更新已经被请求使用了的字节数，多了一个相当于requested 减掉一个*/
return;
}
/** 从已经申请的内存块中申请slab内存块*/
static void *memory_allocate(size_t size) {
void *ret;
if (mem_base == NULL) { /**全局变量指向系统申请时的内存块*/
/* We are not using a preallocated large memory chunk */
ret = malloc(size); /** 表示尚未向系统申请过，这里就直接调用系统调用申请*/
} else {
ret = mem_current; /** mem_current同样是一个全局变量，指向mem_base申请之后剩余的可用内存*/
if (size > mem_avail) { /** 判断申请是不是过大*/
return NULL;
}
/* mem_current pointer _must_ be aligned!!! */
if (size % CHUNK_ALIGN_BYTES) { /** 官方注释这里必须内存对齐*/
size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);
}
mem_current = ((char*)mem_current) + size; /** mem_current向前移动*/
if (size < mem_avail) {
mem_avail -= size; /* 更新全局统计量*/
} else {
mem_avail = 0;
}
}
return ret;
}
/*分配slab块的对外接口，主要是加了锁，基本上do_xxx()函数都是不加锁的*/
void *slabs_alloc(size_t size, unsigned int id) {
void *ret;
pthread_mutex_lock(&slabs_lock);
ret = do_slabs_alloc(size, id);
pthread_mutex_unlock(&slabs_lock);
return ret;
}
...
/**更新已经slabclass使用的字节数*/
void slabs_adjust_mem_requested(unsigned int id, size_t old, size_t ntotal)
{
pthread_mutex_lock(&slabs_lock);
slabclass_t *p;
if (id < POWER_SMALLEST || id > power_largest) {
fprintf(stderr, "Internal error! Invalid slab class\n");
abort();
}
p = &slabclass[id];
p->requested = p->requested - old + ntotal;
pthread_mutex_unlock(&slabs_lock);
}
以上注释仅代表个人见解，若有误导，请见谅！
